Scikit-Learn 완전정복

# 모든 scikit-learn 모델은 이 3단계를 따릅니다

# 1단계: 모델 객체 생성
model = SomeAlgorithm(hyperparameter=value)

# 2단계: 학습 (훈련 데이터를 먹여줌)
model.fit(X_train, y_train)

# 3단계: 예측 (새 데이터에 대한 결과)
predictions = model.predict(X_test)

# (선택) 성능 평가
score = model.score(X_test, y_test)

# 파이썬 버전 확인
python --version
# 또는
python3 --version

# pip로 설치 (가장 일반적)
pip install scikit-learn

# 관련 라이브러리 함께 설치 (권장)
pip install numpy pandas matplotlib scikit-learn

# conda로 설치 (Anaconda 사용자)
conda install scikit-learn

# 특정 버전 설치
pip install scikit-learn==1.8.0

import sklearn
print(sklearn.__version__)
# 출력: 1.8.0

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

print("NumPy:", np.__version__)
print("Pandas:", pd.__version__)
print("모든 라이브러리가 정상 설치되었습니다!")

# ===== 공통 import =====
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 데이터셋
from sklearn.datasets import (
    load_iris, load_wine, load_breast_cancer,
    load_diabetes, fetch_california_housing,
    make_classification, make_regression, make_blobs
)

# 전처리
from sklearn.preprocessing import StandardScaler, MinMaxScaler, LabelEncoder

# 데이터 분할
from sklearn.model_selection import train_test_split

# 평가 지표
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, f1_score,
    confusion_matrix, classification_report,
    mean_squared_error, mean_absolute_error, r2_score
)

# 시각화 설정
plt.rcParams['font.family'] = 'Malgun Gothic'  # Windows 한글
plt.rcParams['axes.unicode_minus'] = False
plt.style.use('dark_background')  # 어두운 배경 스타일

from sklearn.datasets import load_iris

# 데이터셋 로드
iris = load_iris()

# 데이터셋 구조 확인 (Bunch 객체 = 딕셔너리와 비슷)
print("키 목록:", iris.keys())
# dict_keys(['data', 'target', 'frame', 'target_names',
#            'DESCR', 'feature_names', 'filename', 'data_module'])

# 특성 데이터 (X) - 2D 배열 (150행 × 4열)
print("data 형태:", iris.data.shape)      # (150, 4)
print("data 타입:", type(iris.data))    # numpy.ndarray

# 타겟 데이터 (y) - 1D 배열 (150개)
print("target 형태:", iris.target.shape)  # (150,)
print("타겟 값:", np.unique(iris.target)) # [0 1 2]

# 특성 이름과 타겟 이름
print("특성 이름:", iris.feature_names)
# ['sepal length (cm)', 'sepal width (cm)',
#  'petal length (cm)', 'petal width (cm)']

print("타겟 이름:", iris.target_names)
# ['setosa' 'versicolor' 'virginica']

# 데이터셋 설명 보기
print(iris.DESCR[:500])

# DataFrame으로 변환
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['target'] = iris.target
df['species'] = df['target'].map({
    0: 'setosa',
    1: 'versicolor',
    2: 'virginica'
})

# 처음 5행 확인
print(df.head())

# 기본 통계 요약
print(df.describe())

# 정보 확인 (컬럼 타입, 결측치 등)
print(df.info())

# 클래스별 데이터 수
print(df['species'].value_counts())

from sklearn.datasets import make_classification, make_regression, make_blobs

# 분류용 인공 데이터 (1000샘플, 10특성, 2클래스)
X, y = make_classification(
    n_samples=1000,
    n_features=10,
    n_informative=5,     # 실제 유의미한 특성 수
    n_redundant=2,       # 중복 특성 수
    n_classes=2,          # 클래스 수
    random_state=42
)
print("분류 데이터:", X.shape, y.shape)

# 회귀용 인공 데이터 (500샘플, 5특성)
X, y = make_regression(
    n_samples=500,
    n_features=5,
    noise=10,             # 노이즈 정도
    random_state=42
)
print("회귀 데이터:", X.shape, y.shape)

# 군집화용 데이터 (300샘플, 3개 클러스터)
X, y = make_blobs(
    n_samples=300,
    centers=3,            # 클러스터 수
    cluster_std=1.0,      # 클러스터 표준편차
    random_state=42
)
print("군집 데이터:", X.shape, y.shape)

# CSV 파일 로드 (Pandas 활용)
df = pd.read_csv('my_data.csv')

# 특성(X)과 타겟(y)으로 분리
X = df.drop('target_column', axis=1)  # target 열을 제외한 나머지
y = df['target_column']                # target 열만

# NumPy 배열로 변환 (선택)
X = X.values
y = y.values

from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris

# 데이터 준비
iris = load_iris()
X, y = iris.data, iris.target

# 학습용 80% / 테스트용 20%로 분할
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,       # 테스트 비율 (20%)
    random_state=42,     # 재현성을 위한 시드
    stratify=y            # 클래스 비율 유지 (중요!)
)

print(f"전체: {X.shape[0]}개")
print(f"학습: {X_train.shape[0]}개")
print(f"테스트: {X_test.shape[0]}개")

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

# 학습 데이터로 fit (평균, 표준편차 계산) + 변환
X_train_scaled = scaler.fit_transform(X_train)

# 테스트 데이터는 transform만! (학습 데이터의 통계로 변환)
X_test_scaled = scaler.transform(X_test)

print("스케일링 전 평균:", X_train[:, 0].mean().round(2))
print("스케일링 후 평균:", X_train_scaled[:, 0].mean().round(2))
print("스케일링 후 표준편차:", X_train_scaled[:, 0].std().round(2))

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
X_train_minmax = scaler.fit_transform(X_train)
X_test_minmax = scaler.transform(X_test)

print("최소값:", X_train_minmax.min())  # 0.0
print("최대값:", X_train_minmax.max())  # 1.0

from sklearn.impute import SimpleImputer

# 평균값으로 결측치 대체
imputer = SimpleImputer(strategy='mean')
X_train_imputed = imputer.fit_transform(X_train)
X_test_imputed = imputer.transform(X_test)

# strategy 옵션들:
# 'mean'   : 평균값 (숫자형 기본)
# 'median' : 중앙값 (이상치가 있을 때)
# 'most_frequent' : 최빈값 (범주형)
# 'constant' : 지정한 상수값

from sklearn.preprocessing import LabelEncoder, OneHotEncoder

# ① LabelEncoder : 라벨을 0, 1, 2, ...로 변환
le = LabelEncoder()
colors = ['red', 'blue', 'green', 'red', 'blue']
encoded = le.fit_transform(colors)
print(encoded)  # [2 0 1 2 0]

# 복원
print(le.inverse_transform(encoded))  # ['red' 'blue' 'green' 'red' 'blue']

# ② OneHotEncoder : 원-핫 인코딩 (더 많이 사용)
# Pandas get_dummies가 더 간편합니다
df = pd.DataFrame({'color': ['red', 'blue', 'green', 'red']})
df_encoded = pd.get_dummies(df, columns=['color'], drop_first=True)
print(df_encoded)

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# ============================
# STEP 0 : 데이터 준비
# ============================
iris = load_iris()
X, y = iris.data, iris.target

# 학습(80%) / 테스트(20%) 분할
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# ============================
# STEP 1 : 모델 생성
# ============================
# K-최근접 이웃 분류기 (k=5)
model = KNeighborsClassifier(n_neighbors=5)

# ============================
# STEP 2 : 학습 (fit)
# ============================
# 학습 데이터를 모델에 전달하여 패턴을 학습시킵니다
model.fit(X_train, y_train)

# ============================
# STEP 3 : 예측 (predict)
# ============================
# 테스트 데이터로 예측값을 생성합니다
y_pred = model.predict(X_test)

print("실제값 :", y_test[:10])
print("예측값 :", y_pred[:10])

# ============================
# STEP 4 : 평가 (score)
# ============================
accuracy = accuracy_score(y_test, y_pred)
print(f"\n정확도: {accuracy:.4f}")
print(f"정확도: {accuracy * 100:.1f}%")

# model.score()로도 동일한 결과
print(f"score(): {model.score(X_test, y_test):.4f}")

# 새로운 붓꽃 데이터 (꽃받침 길이, 꽃받침 폭, 꽃잎 길이, 꽃잎 폭)
new_flower = [[5.0, 3.5, 1.5, 0.3]]
prediction = model.predict(new_flower)
print(f"예측 클래스: {prediction[0]}")
print(f"예측 품종: {iris.target_names[prediction[0]]}")

# 여러 개 동시 예측
new_flowers = [
    [5.0, 3.5, 1.5, 0.3],  # 아마 setosa?
    [6.5, 3.0, 5.2, 2.0],  # 아마 virginica?
    [5.8, 2.7, 4.1, 1.0],  # 아마 versicolor?
]
predictions = model.predict(new_flowers)
for flower, pred in zip(new_flowers, predictions):
    print(f"  {flower} → {iris.target_names[pred]}")

from sklearn.datasets import load_diabetes
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

# 데이터 준비
diabetes = load_diabetes()
X, y = diabetes.data, diabetes.target
print(f"데이터 형태: X={X.shape}, y={y.shape}")
print(f"특성 이름: {diabetes.feature_names}")

# 분할
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 모델 학습
model = LinearRegression()
model.fit(X_train, y_train)

# 예측
y_pred = model.predict(X_test)

# 평가
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)

print(f"\n=== 선형 회귀 결과 ===")
print(f"MSE  (평균 제곱 오차): {mse:.2f}")
print(f"RMSE (제곱근 MSE)   : {rmse:.2f}")
print(f"R² Score           : {r2:.4f}")

# 회귀 계수 (각 특성의 기여도) 확인
print(f"\n절편(intercept): {model.intercept_:.2f}")
for name, coef in zip(diabetes.feature_names, model.coef_):
    print(f"  {name:>5s}: {coef:>8.2f}")

from sklearn.linear_model import Ridge, Lasso

# Ridge 회귀 (L2 규제 : 계수를 작게 유지)
ridge = Ridge(alpha=1.0)
ridge.fit(X_train, y_train)
print(f"Ridge R²: {ridge.score(X_test, y_test):.4f}")

# Lasso 회귀 (L1 규제 : 불필요한 특성의 계수를 0으로)
lasso = Lasso(alpha=1.0)
lasso.fit(X_train, y_train)
print(f"Lasso R²: {lasso.score(X_test, y_test):.4f}")

# Lasso는 특성 선택 효과가 있음
print(f"\nLasso가 0으로 만든 특성 수: {sum(lasso.coef_ == 0)}")

from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report

# 데이터 준비
cancer = load_breast_cancer()
X, y = cancer.data, cancer.target
print(f"데이터 형태: {X.shape}")
print(f"클래스: {cancer.target_names}")  # ['malignant' 'benign']

# 분할
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 스케일링 (로지스틱 회귀는 스케일링이 중요합니다)
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

# 모델 학습
model = LogisticRegression(max_iter=10000, random_state=42)
model.fit(X_train_s, y_train)

# 예측 및 평가
y_pred = model.predict(X_test_s)
print(f"\n정확도: {accuracy_score(y_test, y_pred):.4f}")
print("\n상세 리포트:")
print(classification_report(y_test, y_pred,
      target_names=cancer.target_names))

# predict_proba(): 각 클래스의 확률 반환
y_proba = model.predict_proba(X_test_s)

# 처음 5개 샘플의 확률
for i in range(5):
    print(f"샘플 {i}: 악성={y_proba[i][0]:.4f}, "
          f"양성={y_proba[i][1]:.4f} → "
          f"예측={cancer.target_names[y_pred[i]]}")

from sklearn.datasets import load_wine
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 와인 데이터 준비
wine = load_wine()
X, y = wine.data, wine.target

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 스케일링 (KNN은 거리 기반이므로 반드시 스케일링!)
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

# K값 1~20까지 변화시키며 정확도 비교
k_range = range(1, 21)
scores = []

for k in k_range:
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit(X_train_s, y_train)
    score = knn.score(X_test_s, y_test)
    scores.append(score)
    print(f"K={k:2d} → 정확도: {score:.4f}")

best_k = list(k_range)[scores.index(max(scores))]
print(f"\n최적 K: {best_k} (정확도: {max(scores):.4f})")

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report

# 데이터 준비
iris = load_iris()
X, y = iris.data, iris.target

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 결정 트리 모델 (깊이 3으로 제한하여 과적합 방지)
tree = DecisionTreeClassifier(
    max_depth=3,            # 트리의 최대 깊이
    min_samples_split=5,    # 분할에 필요한 최소 샘플 수
    random_state=42
)
tree.fit(X_train, y_train)

# 예측 및 평가
y_pred = tree.predict(X_test)
print(f"정확도: {accuracy_score(y_test, y_pred):.4f}")

# 트리 구조를 텍스트로 출력
tree_rules = export_text(tree, feature_names=iris.feature_names)
print("\n결정 트리 규칙:")
print(tree_rules)

# 특성 중요도 확인
importances = tree.feature_importances_
for name, imp in sorted(
    zip(iris.feature_names, importances),
    key=lambda x: x[1],
    reverse=True
):
    print(f"  {name:20s}: {imp:.4f} {'█' * int(imp * 50)}")

from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report

# 데이터 준비
cancer = load_breast_cancer()
X, y = cancer.data, cancer.target
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 랜덤 포레스트 (100개의 트리)
rf = RandomForestClassifier(
    n_estimators=100,     # 트리 개수
    max_depth=10,          # 각 트리의 최대 깊이
    min_samples_split=5,  # 분할 최소 샘플
    random_state=42,
    n_jobs=-1              # 모든 CPU 코어 사용
)
rf.fit(X_train, y_train)

# 평가
y_pred = rf.predict(X_test)
print(f"랜덤 포레스트 정확도: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred,
      target_names=cancer.target_names))

# 상위 10개 중요 특성
print("=== 특성 중요도 TOP 10 ===")
feat_imp = sorted(
    zip(cancer.feature_names, rf.feature_importances_),
    key=lambda x: x[1], reverse=True
)
for name, imp in feat_imp[:10]:
    print(f"  {name:25s}: {imp:.4f}")

from sklearn.ensemble import GradientBoostingClassifier

gb = GradientBoostingClassifier(
    n_estimators=100,
    learning_rate=0.1,   # 학습률 (작을수록 신중, 느림)
    max_depth=3,
    random_state=42
)
gb.fit(X_train, y_train)
print(f"그래디언트 부스팅 정확도: {gb.score(X_test, y_test):.4f}")

from sklearn.svm import SVC
from sklearn.datasets import load_wine
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

wine = load_wine()
X, y = wine.data, wine.target
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# SVM은 반드시 스케일링!
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

# 다양한 커널 비교
kernels = ['linear', 'rbf', 'poly']
for kernel in kernels:
    svm = SVC(kernel=kernel, random_state=42)
    svm.fit(X_train_s, y_train)
    score = svm.score(X_test_s, y_test)
    print(f"  커널: {kernel:8s} → 정확도: {score:.4f}")

from sklearn.metrics import (
    confusion_matrix, classification_report,
    accuracy_score, precision_score, recall_score, f1_score
)
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    cancer.data, cancer.target,
    test_size=0.2, random_state=42, stratify=cancer.target
)

rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)
y_pred = rf.predict(X_test)

# 혼동 행렬
cm = confusion_matrix(y_test, y_pred)
print("혼동 행렬:")
print(cm)

# 상세 리포트 (한 번에 모든 지표 확인)
print("\n분류 리포트:")
print(classification_report(y_test, y_pred,
      target_names=['악성', '양성']))

from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
import numpy as np

# y_test, y_pred가 있다고 가정
mse  = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
mae  = mean_absolute_error(y_test, y_pred)
r2   = r2_score(y_test, y_pred)

print(f"MSE  : {mse:.4f}")
print(f"RMSE : {rmse:.4f}")
print(f"MAE  : {mae:.4f}")
print(f"R²   : {r2:.4f}")

from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
import numpy as np

iris = load_iris()
X, y = iris.data, iris.target

model = RandomForestClassifier(n_estimators=100, random_state=42)

# 5-Fold 교차 검증
scores = cross_val_score(
    model, X, y,
    cv=5,                   # 5개 Fold
    scoring='accuracy'     # 평가 지표
)

print("각 Fold의 정확도:", scores)
print(f"평균 정확도: {scores.mean():.4f}")
print(f"표준 편차 : {scores.std():.4f}")
print(f"신뢰 구간 : {scores.mean():.4f} ± {scores.std() * 2:.4f}")

from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC

models = {
    'Logistic Regression': LogisticRegression(max_iter=10000),
    'KNN (k=5)'          : KNeighborsClassifier(n_neighbors=5),
    'Decision Tree'      : DecisionTreeClassifier(random_state=42),
    'Random Forest'      : RandomForestClassifier(random_state=42),
    'SVM (RBF)'          : SVC(random_state=42),
}

print(f"{'모델':25s} {'평균':>8s} {'표준편차':>8s}")
print("-" * 45)
for name, model in models.items():
    scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
    print(f"{name:25s} {scores.mean():>8.4f} {scores.std():>8.4f}")

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

# 데이터 준비
cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    cancer.data, cancer.target,
    test_size=0.2, random_state=42, stratify=cancer.target
)

# 탐색할 하이퍼파라미터 조합 정의
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [3, 5, 10, None],
    'min_samples_split': [2, 5, 10],
}
# 총 조합 수: 3 × 4 × 3 = 36가지

# GridSearchCV 실행
grid_search = GridSearchCV(
    estimator=RandomForestClassifier(random_state=42),
    param_grid=param_grid,
    cv=5,                    # 5-Fold 교차 검증
    scoring='accuracy',
    n_jobs=-1,                # 전체 CPU 사용
    verbose=1                 # 진행 상황 출력
)
grid_search.fit(X_train, y_train)

# 결과 확인
print(f"\n최적 파라미터: {grid_search.best_params_}")
print(f"최고 교차검증 점수: {grid_search.best_score_:.4f}")
print(f"테스트 세트 점수: {grid_search.score(X_test, y_test):.4f}")

# 최적 모델 바로 사용
best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test)

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform

# 파라미터 분포 정의 (범위에서 랜덤 샘플링)
param_dist = {
    'n_estimators': randint(50, 500),
    'max_depth': randint(2, 20),
    'min_samples_split': randint(2, 20),
    'min_samples_leaf': randint(1, 10),
}

random_search = RandomizedSearchCV(
    estimator=RandomForestClassifier(random_state=42),
    param_distributions=param_dist,
    n_iter=50,              # 50번만 무작위 시도
    cv=5,
    scoring='accuracy',
    random_state=42,
    n_jobs=-1
)
random_search.fit(X_train, y_train)

print(f"최적 파라미터: {random_search.best_params_}")
print(f"최고 점수: {random_search.best_score_:.4f}")

from sklearn.pipeline import Pipeline, make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split, cross_val_score

wine = load_wine()
X, y = wine.data, wine.target
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 파이프라인 생성: 스케일링 → SVM
pipe = Pipeline([
    ('scaler', StandardScaler()),    # 1단계: 스케일링
    ('svm',    SVC(kernel='rbf'))     # 2단계: 모델
])

# 또는 간단히 make_pipeline 사용
pipe = make_pipeline(StandardScaler(), SVC(kernel='rbf'))

# fit 한 번으로 전처리 + 학습 완료!
pipe.fit(X_train, y_train)

# predict 한 번으로 전처리 + 예측 완료!
score = pipe.score(X_test, y_test)
print(f"파이프라인 정확도: {score:.4f}")

# 교차 검증도 파이프라인 그대로 사용
cv_scores = cross_val_score(pipe, X, y, cv=5)
print(f"교차검증 평균: {cv_scores.mean():.4f}")

from sklearn.model_selection import GridSearchCV

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('svm', SVC())
])

# 파이프라인 내부 파라미터는 '단계이름__파라미터명' 형태로 접근
param_grid = {
    'svm__C': [0.1, 1, 10, 100],
    'svm__kernel': ['rbf', 'linear'],
    'svm__gamma': ['scale', 'auto', 0.01, 0.1],
}

grid = GridSearchCV(pipe, param_grid, cv=5, scoring='accuracy', n_jobs=-1)
grid.fit(X_train, y_train)

print(f"최적 파라미터: {grid.best_params_}")
print(f"최고 점수: {grid.best_score_:.4f}")
print(f"테스트 점수: {grid.score(X_test, y_test):.4f}")

from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
from sklearn.preprocessing import StandardScaler
import numpy as np

# 인공 데이터 생성 (3개 클러스터)
X, y_true = make_blobs(
    n_samples=300, centers=3,
    cluster_std=1.0, random_state=42
)

# 스케일링
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# K-Means 모델
kmeans = KMeans(
    n_clusters=3,         # 클러스터 수
    init='k-means++',     # 초기 중심 설정 방법
    n_init=10,             # 초기화 반복 횟수
    max_iter=300,          # 최대 반복 횟수
    random_state=42
)
kmeans.fit(X_scaled)

# 결과 확인
print("클러스터 라벨:", np.unique(kmeans.labels_))
print("클러스터별 데이터 수:")
for i in range(3):
    print(f"  클러스터 {i}: {(kmeans.labels_ == i).sum()}개")
print(f"관성(Inertia): {kmeans.inertia_:.2f}")

# 엘보우 방법으로 최적 K 탐색
inertias = []
K_range = range(1, 11)

for k in K_range:
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    km.fit(X_scaled)
    inertias.append(km.inertia_)
    print(f"K={k:2d} → Inertia: {km.inertia_:.2f}")

# 시각화
plt.figure(figsize=(8, 4))
plt.plot(K_range, inertias, 'o-', color='#f57c00')
plt.xlabel('K (클러스터 수)')
plt.ylabel('Inertia')
plt.title('엘보우 방법')
plt.grid(True, alpha=0.3)
plt.show()

from sklearn.metrics import silhouette_score

for k in range(2, 8):
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = km.fit_predict(X_scaled)
    sil = silhouette_score(X_scaled, labels)
    print(f"K={k} → 실루엣 점수: {sil:.4f}")

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_breast_cancer
import numpy as np

# 30개 특성을 가진 유방암 데이터
cancer = load_breast_cancer()
X = cancer.data
print(f"원본 특성 수: {X.shape[1]}")   # 30

# PCA 전 반드시 스케일링
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# PCA로 30차원 → 2차원 축소
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)
print(f"축소 후 특성 수: {X_pca.shape[1]}")   # 2

# 각 주성분이 설명하는 분산 비율
print(f"\n주성분별 설명 분산 비율:")
for i, ratio in enumerate(pca.explained_variance_ratio_):
    print(f"  PC{i+1}: {ratio:.4f} ({ratio*100:.1f}%)")
print(f"  합계: {pca.explained_variance_ratio_.sum():.4f}")

from sklearn.pipeline import make_pipeline
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

# PCA 적용 전후 성능 비교
# 원본 (30차원)
pipe_full = make_pipeline(
    StandardScaler(),
    RandomForestClassifier(n_estimators=100, random_state=42)
)
score_full = cross_val_score(pipe_full, cancer.data, cancer.target, cv=5)

# PCA 적용 (10차원으로 축소)
pipe_pca = make_pipeline(
    StandardScaler(),
    PCA(n_components=10),
    RandomForestClassifier(n_estimators=100, random_state=42)
)
score_pca = cross_val_score(pipe_pca, cancer.data, cancer.target, cv=5)

print(f"원본 (30차원): {score_full.mean():.4f}")
print(f"PCA  (10차원): {score_pca.mean():.4f}")

import numpy as np
import pandas as pd
from sklearn.datasets import fetch_california_housing

# 데이터 로드
housing = fetch_california_housing()
df = pd.DataFrame(housing.data, columns=housing.feature_names)
df['MedHouseVal'] = housing.target  # 타겟: 중간 집값 (단위: $100,000)

print("=== 데이터셋 정보 ===")
print(f"크기: {df.shape}")
print(f"\n특성 이름: {housing.feature_names}")
print(f"\n처음 5행:")
print(df.head())
print(f"\n기본 통계:")
print(df.describe().round(2))
print(f"\n결측치:")
print(df.isnull().sum())

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# X, y 분리
X = df.drop('MedHouseVal', axis=1)
y = df['MedHouseVal']

# 분할
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

print(f"학습 세트: {X_train.shape}")
print(f"테스트 세트: {X_test.shape}")

# 스케일링
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.svm import SVR
from sklearn.metrics import mean_squared_error, r2_score

models = {
    'Linear Regression'  : LinearRegression(),
    'Ridge (α=1)'        : Ridge(alpha=1.0),
    'Lasso (α=0.01)'     : Lasso(alpha=0.01),
    'Decision Tree'      : DecisionTreeRegressor(max_depth=10, random_state=42),
    'Random Forest'      : RandomForestRegressor(n_estimators=100,
                           max_depth=15, random_state=42, n_jobs=-1),
    'Gradient Boosting'  : GradientBoostingRegressor(n_estimators=200,
                           max_depth=5, learning_rate=0.1, random_state=42),
    'SVR (RBF)'          : SVR(kernel='rbf', C=10),
}

print(f"{'모델':25s} {'RMSE':>8s} {'R²':>8s}")
print("-" * 45)

results = {}
for name, model in models.items():
    model.fit(X_train_s, y_train)
    y_pred = model.predict(X_test_s)
    rmse = np.sqrt(mean_squared_error(y_test, y_pred))
    r2 = r2_score(y_test, y_pred)
    results[name] = {'rmse': rmse, 'r2': r2}
    print(f"{name:25s} {rmse:>8.4f} {r2:>8.4f}")

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform

# Gradient Boosting 튜닝
param_dist = {
    'n_estimators': randint(100, 500),
    'max_depth': randint(3, 10),
    'learning_rate': uniform(0.01, 0.19),
    'min_samples_split': randint(2, 20),
    'subsample': uniform(0.7, 0.3),
}

random_search = RandomizedSearchCV(
    GradientBoostingRegressor(random_state=42),
    param_distributions=param_dist,
    n_iter=30,
    cv=5,
    scoring='r2',
    random_state=42,
    n_jobs=-1
)
random_search.fit(X_train_s, y_train)

print(f"최적 파라미터: {random_search.best_params_}")
print(f"최고 CV R²: {random_search.best_score_:.4f}")

# 최종 평가
best_model = random_search.best_estimator_
y_pred_best = best_model.predict(X_test_s)
final_rmse = np.sqrt(mean_squared_error(y_test, y_pred_best))
final_r2 = r2_score(y_test, y_pred_best)
print(f"\n최종 테스트 RMSE: {final_rmse:.4f}")
print(f"최종 테스트 R²  : {final_r2:.4f}")

# 최적 모델의 특성 중요도
importances = best_model.feature_importances_
feat_imp = sorted(
    zip(housing.feature_names, importances),
    key=lambda x: x[1],
    reverse=True
)

print("=== 특성 중요도 ===")
for name, imp in feat_imp:
    bar = '█' * int(imp * 50)
    print(f"  {name:12s}: {imp:.4f} {bar}")

# =============================================
# Scikit-Learn 치트시트 - 한눈에 보는 핵심 코드
# =============================================

# ── 1. 데이터 분할 ──
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# ── 2. 전처리 ──
from sklearn.preprocessing import StandardScaler, MinMaxScaler
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)  # 학습: fit + transform
X_test_s  = scaler.transform(X_test)       # 테스트: transform만!

# ── 3. 핵심 3단계 ──
model = SomeAlgorithm(params)  # 생성
model.fit(X_train, y_train)    # 학습
y_pred = model.predict(X_test) # 예측

# ── 4. 분류 알고리즘 ──
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.svm import SVC

# ── 5. 회귀 알고리즘 ──
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.svm import SVR

# ── 6. 비지도 학습 ──
from sklearn.cluster import KMeans, DBSCAN
from sklearn.decomposition import PCA

# ── 7. 분류 평가 지표 ──
from sklearn.metrics import (
    accuracy_score,          # 정확도
    precision_score,         # 정밀도
    recall_score,            # 재현율
    f1_score,                # F1
    confusion_matrix,        # 혼동 행렬
    classification_report    # 종합 리포트
)

# ── 8. 회귀 평가 지표 ──
from sklearn.metrics import (
    mean_squared_error,      # MSE
    mean_absolute_error,     # MAE
    r2_score                 # R² Score
)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))

# ── 9. 교차 검증 ──
from sklearn.model_selection import cross_val_score
scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')

# ── 10. 하이퍼파라미터 튜닝 ──
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
grid = GridSearchCV(model, param_grid, cv=5, scoring='accuracy')
grid.fit(X_train, y_train)
grid.best_params_       # 최적 파라미터
grid.best_score_        # 최고 교차검증 점수
grid.best_estimator_    # 최적 모델 객체

# ── 11. 파이프라인 ──
from sklearn.pipeline import make_pipeline
pipe = make_pipeline(StandardScaler(), RandomForestClassifier())
pipe.fit(X_train, y_train)
pipe.score(X_test, y_test)

# ── 12. 모델 저장/불러오기 ──
import joblib
joblib.dump(model, 'model.pkl')              # 저장
loaded_model = joblib.load('model.pkl')      # 불러오기